home *** CD-ROM | disk | FTP | other *** search
/ Network PC / Network PC.iso / amiga utilities / communication / internet / amitcp3.0b / src.lha / src / util / inetd / inetd.c next >
Encoding:
C/C++ Source or Header  |  1996-09-08  |  42.4 KB  |  1,692 lines
  1. RCS_ID_C="$Id: inetd.c,v 3.4 1994/05/02 19:43:59 jraja Exp $";
  2. /*
  3.  * inetd.c --- Internet super-server
  4.  *
  5.  * Author: ppessi <Pekka.Pessi@hut.fi>
  6.  *
  7.  * Copyright © 1993 AmiTCP/IP Group, <amitcp-group@hut.fi>
  8.  *                  Helsinki University of Technology, Finland.
  9.  *                  All rights reserved.
  10.  *
  11.  * Created      : Mon May 24 00:34:11 1993 ppessi
  12.  * Last modified: Sat Feb 26 05:54:05 1994 ppessi
  13.  *
  14.  * $Log: inetd.c,v $
  15.  * Revision 3.4  1994/05/02  19:43:59  jraja
  16.  * Changed exitcode() to return 0 for concistency with other progs.
  17.  * Removed inclusion of the (removed) inetdlib.h.
  18.  *
  19.  * Revision 3.3  1994/04/25  14:51:19  jraja
  20.  * Fixed server argument parsing bugs.
  21.  *
  22.  * Revision 3.2  1994/02/26  09:23:56  ppessi
  23.  * Fixed SAS C 6.51 incompatibilities.
  24.  * Fixed bug in timer handling
  25.  *
  26.  * Revision 3.1  1994/02/24  03:35:35  ppessi
  27.  * Changed the VERSTAG and copyright formats slightly
  28.  *
  29.  * Revision 1.11  1993/10/21  01:51:20  ppessi
  30.  * Added correct prototype for CheckIO()
  31.  *
  32.  * Revision 1.10  1993/10/20  05:31:07  ppessi
  33.  * Using now gettimeofday().
  34.  *
  35.  * Revision 1.1  93/05/24  21:42:36  ppessi
  36.  * Original BSD code.
  37.  */
  38.  
  39. #include "inetd_rev.h"
  40. static const char version[] = VERSTAG " "
  41.      "Copyright © 1993 AmiTCP/IP Group, <amitcp-group@hut.fi>\n"
  42.                       "Helsinki University of Technology, Finland.\n"
  43. "@(#) Copyright © 1983 The Regents of the University of California.\n"
  44.                       "All rights reserved.\n";
  45.  
  46. /*
  47.  * Copyright (c) 1983,1991 The Regents of the University of California.
  48.  * All rights reserved.
  49.  *
  50.  * Redistribution and use in source and binary forms, with or without
  51.  * modification, are permitted provided that the following conditions
  52.  * are met:
  53.  * 1. Redistributions of source code must retain the above copyright
  54.  *    notice, this list of conditions and the following disclaimer.
  55.  * 2. Redistributions in binary form must reproduce the above copyright
  56.  *    notice, this list of conditions and the following disclaimer in the
  57.  *    documentation and/or other materials provided with the distribution.
  58.  * 3. All advertising materials mentioning features or use of this software
  59.  *    must display the following acknowledgement:
  60.  *    This product includes software developed by the University of
  61.  *    California, Berkeley and its contributors.
  62.  * 4. Neither the name of the University nor the names of its contributors
  63.  *    may be used to endorse or promote products derived from this software
  64.  *    without specific prior written permission.
  65.  *
  66.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  67.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  68.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  69.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  70.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  71.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  72.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  73.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  74.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  75.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  76.  * SUCH DAMAGE.
  77.  */
  78.  
  79. /****** netutil.doc/inetd ***************************************************
  80. *
  81. *  NAME
  82. *        inetd - internet ``super-server''
  83. *
  84. *  TEMPLATE
  85. *       inetd DEBUG/S CONFIGFILE
  86. *
  87. *  DESCRIPTION
  88. *
  89. *       Inetd should be run when the AmiTCP/IP protocol stack is started.
  90. *       Inetd listens for connections on certain internet sockets.  When a
  91. *       connection is found on one of its sockets, it decides what service the
  92. *       socket corresponds to, and invokes a program to service the request.
  93. *       After the program is finished, it continues to listen on the socket
  94. *       (except in some cases which will be described below).  Essentially,
  95. *       inetd allows running one daemon to invoke several others, reducing
  96. *       load on the system.
  97. *
  98. *  PARAMETERS
  99. *       DEBUG      Turns on debugging.
  100. *
  101. *       CONFIGFILE Specifies the configuration file name.
  102. *
  103. *  CONFIGURATION
  104. *
  105. *       Upon execution, inetd reads its configuration information from a
  106. *       configuration file which, by default, is AmiTCP:db/inetd.conf. There
  107. *       must be an entry for each field of the configuration file, with
  108. *       entries for each field separated by a tab or a space.  Comments are
  109. *       denoted by a ``#'' at the beginning of a line or ``;'' anywhere in the
  110. *       line. There must be an entry for each field. The fields of the
  111. *       configuration file are as follows:
  112. *
  113. *             service name
  114. *             socket type
  115. *             protocol
  116. *             wait/nowait
  117. *             user
  118. *             server program
  119. *             server program name
  120. *             server program arguments
  121. *
  122. *       The service-name entry is the name of a valid service in the
  123. *       netdatabase.  For ``internal'' services (discussed below), the service
  124. *       name must be the official name of the service.
  125. *
  126. *       The socket-type should be one of ``stream'', ``dgram'', ``raw'',
  127. *       ``rdm'', or ``seqpacket'', depending on whether the socket is a
  128. *       stream, datagram, raw, reliably delivered message, or sequenced packet
  129. *       socket. Current system supports only stream, datagram and raw
  130. *       protocols.
  131. *
  132. *       The protocol must be a valid protocol as given in netdatabase.
  133. *       Examples might be ``tcp'' or ``udp''.
  134. *
  135. *       The wait/nowait entry is useful for datagram sockets only (other
  136. *       sockets should have a ``nowait'' entry in this space).  If a datagram
  137. *       server connects to its peer, freeing the socket so inetd can received
  138. *       further messages on the socket, it is said to be a ``multi-threaded''
  139. *       server, and should use the ``nowait'' entry.  For datagram servers
  140. *       which process all incoming datagrams on a socket and eventually time
  141. *       out, the server is said to be ``single-threaded'' and should use a
  142. *       ``wait'' entry.  Comsat and talkd are both examples of the latter type
  143. *       of datagram server.
  144. *
  145. *       The user entry should contain the user name of the user as whom the
  146. *       server should run. This field is for Unix and future compability
  147. *       only.
  148. *
  149. *       The server-program entry should contain the pathname of the program
  150. *       which is to be executed by inetd when a request is found on its
  151. *       socket.  If the server program is resident, the path name should be
  152. *       suppressed. If inetd provides this service internally, this entry
  153. *       should be ``internal''.
  154. *
  155. *       The server-program-name is CLI command name for the server process. It
  156. *       is shown in the printout of ``status'' command. (Task name of the
  157. *       server process is the service and the peer address, e.g. ``echo
  158. *       [192.233.15.19]''.) This and argument entry are optional.
  159. *
  160. *       The server program arguments should be just as arguments normally are.
  161. *
  162. *       Inetd provides several ``trivial'' services internally by use of
  163. *       routines within itself.  These services are ``echo'', ``discard'',
  164. *       ``chargen'' (character generator), ``daytime'' (human readable time),
  165. *       and ``time'' (machine readable time, in the form of the number of
  166. *       seconds since mid­ night, January 1, 1900).  All of these services are
  167. *       TCP and UDP based.  For details of these services, consult the
  168. *       appropriate RFC from the Network Information Center.
  169. *
  170. *       Inetd rereads its configuration file when it receives the CTRL-F
  171. *       signal.  Services may be added, deleted or modified when the
  172. *       configuration file is reread.
  173. *
  174. *  HISTORY
  175. *       The inetd command appeared in 4.3BSD system.
  176. *
  177. *  SEE ALSO
  178. *
  179. *****************************************************************************
  180. *
  181. */
  182.  
  183. /*
  184.  * Inetd - Internet super-server
  185.  *
  186.  * This program invokes all internet services as needed.
  187.  * connection-oriented services are invoked each time a connection is
  188.  * made, by creating a process. Created server process is passed the
  189.  * connection as file descriptor 0 and is expected to do a getpeername
  190.  * to find out the source host and port.
  191.  *
  192.  * Datagram oriented services are invoked when a datagram arrives; a
  193.  * process is created and passed a pending message on file descriptor
  194.  * 0. Datagram servers may either connect to their peer, freeing up
  195.  * the original socket for inetd to receive further messages on, or
  196.  * ``take over the socket'', processing all arriving datagrams and,
  197.  * eventually, timing out. The first type of server is said to
  198.  * be ``multi-threaded''; the second type of server
  199.  * ``single-threaded''.
  200.  *
  201.  * Inetd uses a configuration file which is read at startup and,
  202.  * possibly, at some later time in response to a signal CTRL_F.  The
  203.  * configuration file is parsed with standard DOS functions with
  204.  * template given below. Multiple line entries must have a ``+'' char at
  205.  * the end of the file.
  206.  *
  207.  *     service             must be in /etc/services
  208.  *    socket type            stream/dgram/raw/rdm/seqpacket
  209.  *    protocol            must be in /etc/protocols
  210.  *    dowait                    single-threaded/multi-threaded
  211.  *    user                user to run daemon as
  212.  *    server program            full path name
  213.  *    server program name        CLI command name (optional)
  214.  *    server program arguments    Normal command argument line 
  215.  *
  216.  * Comment lines are indicated by a `#' in column 1. 
  217.  */
  218.  
  219. #include <sys/param.h>
  220. #include <sys/stat.h>
  221. #include <sys/ioctl.h>
  222. #include <sys/socket.h>
  223. #include <sys/time.h>
  224.  
  225. #include <netinet/in.h>
  226. #include <arpa/inet.h>
  227.  
  228. #include <errno.h>
  229. #include <signal.h>
  230. #include <netdb.h>
  231. #include <stdio.h>
  232. #include <string.h>
  233. #include <stdlib.h>
  234. #include <time.h>
  235. #include <stdarg.h>
  236. #include <syslog.h>
  237.  
  238. #ifdef AMIGA
  239. #include <exec/execbase.h>
  240. #include <exec/memory.h>
  241. #include <devices/timer.h>
  242. #include <dos/dostags.h>
  243. extern struct ExecBase *SysBase;
  244. #if __SASC
  245. #include <proto/socket.h>
  246. #include <proto/dos.h>
  247. #include <clib/exec_protos.h>
  248. #include <pragmas/exec_sysbase_pragmas.h>
  249. #include <pragmas/timer_pragmas.h>
  250. /* #elif __GNUC__
  251. #include <inline/socket.h>
  252. #include <inline/exec.h>
  253. */
  254. #else 
  255. #error Unsupported compiler
  256. #include <clib/socket_protos.h>
  257. #endif
  258.  
  259. /* Correct prototype for the CheckIO.
  260.  * (The one in clib/exec_protos.h has wrong return value type: BOOL (16 bits) 
  261.  * instead of a pointer (32 bits)!)
  262.  */
  263. struct IORequest * CheckIO(struct IORequest *req);
  264. #else /* def AMIGA */
  265. #include <pwd.h>
  266. #include <sys/file.h>
  267. #include <sys/wait.h>
  268. #include <sys/resource.h>
  269. #endif
  270.  
  271. #include "inetd.h"
  272.  
  273. /* don't start more than TOOMANY servers in CNT_INTVL seconds */
  274. #define    TOOMANY        10
  275. #define    CNT_INTVL    60        
  276.  
  277. #define    RETRYTIME    (60*10)        /* retry after bind or server fail */
  278.  
  279. #define INETDNAME "inetd"
  280.  
  281. #define MAXARGS 8
  282. enum fileargs 
  283. { 
  284.   service = 0, socket_type, protocol, wait, user, server, cmdname, arguments
  285. };
  286. #define TYPETEMPLATE "stream,dgram,raw,rdm,seqpacket"
  287. #define WAITTEMPLATE "nowait,wait"
  288.  
  289. void reapchild(void);
  290. void startserver(register struct servtab *sep, long ctrl);
  291. void askalarm(long seconds);
  292. void getalarm(void);
  293. void config(void);
  294. void retry(void);
  295. void setup(register struct servtab *sep);
  296. struct servtab *enter(struct servtab *cp);
  297.  
  298. int setconfig(void);
  299. struct servtab *getconfigent(void);
  300. void freeconfig(register struct servtab *cp);
  301. void endconfig(void);
  302. void print_service(char *action, struct servtab *sep);
  303.  
  304. ASM LONG exitcode(REG(d0) LONG status, REG(d1) LONG exitmessage);
  305. LONG start_builtin(void);
  306. void setproctitle(char *a, int s);
  307.  
  308. UBYTE *proctitle(char *a, int s);
  309. void  amigainit(void);
  310. void amigadeinit(void);
  311. static ULONG csprintf(struct CSource *buf, const char *fmt, ...);
  312.  
  313. int    nsock = 0, maxsock = 0;
  314. fd_set    allsock;
  315. int    options = 0;
  316. struct    servent *sp = NULL;
  317.  
  318. /* 
  319.  * We create a "process table" for builtins, because they 
  320.  * must be waited as they use the same code segment as we do 
  321.  */
  322. #define MAX_BUILTIN_PROC 16
  323. int builtins_started = 0;
  324. long ptable[MAX_BUILTIN_PROC] = { 0 };
  325.  
  326. struct DaemonPort *dport = NULL;
  327.  
  328. #define DO_WAIT   ((struct DaemonMessage *)1)
  329. #define DONT_WAIT ((struct DaemonMessage *)NULL)
  330.  
  331. struct MsgPort *tport = NULL;
  332. struct timerequest *tmsg = NULL;
  333. int   timer_is_open = 0;
  334. #define TimerBase (tmsg->tr_node.io_Device)
  335.  
  336. struct    servtab {
  337.     char    *se_service;        /* name of service */
  338.     long    se_socktype;        /* type of socket to use */
  339.     char    *se_proto;        /* protocol used */
  340.     struct     DaemonMessage *se_wait; /* single threaded server */
  341.     char    *se_user;        /* user name to run as */
  342.     struct    biltin *se_bi;        /* if built-in, description */
  343.     char    *se_server;        /* server program */
  344.     char    *se_argv0;            /* cli name for daemon */
  345.     char    *se_argv;            /* program arguments */
  346.     long    se_fd;            /* open descriptor */
  347.     struct    sockaddr_in se_ctrladdr;/* bound address */
  348.     struct    timeval se_time;    /* start of se_count */
  349.     struct    servtab *se_next;
  350.     short    se_checked;        /* looked at during merge */
  351.     short    se_count;        /* number started since se_time */
  352. } *servtab;
  353.  
  354. /* 
  355.  * Internal Services 
  356.  *
  357.  * Because Data Segment is *not* duplicated by CreateNewProc 
  358.  * server routines must be re-entrable and not touch global data
  359.  */ 
  360. int echo_stream(void *SocketBase, int s, struct servtab *sep);
  361. int echo_dg(void *SocketBase, int s, struct servtab *sep);
  362. int discard_stream(void *SocketBase, int s, struct servtab *sep);
  363. int discard_dg(void *SocketBase, int s, struct servtab *sep); 
  364. int machtime_stream(void *SocketBase, int s, struct servtab *sep);
  365. int machtime_dg(void *SocketBase, int s, struct servtab *sep); 
  366. int daytime_stream(void *SocketBase, int s, struct servtab *sep);
  367. int daytime_dg(void *SocketBase, int s, struct servtab *sep);
  368. int chargen_stream(void *SocketBase, int s, struct servtab *sep);
  369. int chargen_dg(void *SocketBase, int s, struct servtab *sep);
  370.  
  371. struct biltin {
  372.     char    *bi_service;        /* internally provided service name */
  373.     int    bi_socktype;        /* type of socket supported */
  374.     int    bi_process;        /* 1 if should start a process */
  375.     struct    DaemonMessage *bi_wait;    /* DO_WAIT if should wait for child */
  376.     int    (*bi_fn)(void *SocketBase, int s, struct servtab *sep);
  377.                         /* function which performs it */
  378. } biltins[] = {
  379.     /* Echo received data */
  380.     "echo",        SOCK_STREAM,    1, DONT_WAIT,    echo_stream,
  381.     "echo",        SOCK_DGRAM,    0, DONT_WAIT,    echo_dg,
  382.  
  383.     /* Internet /dev/null */
  384.     "discard",    SOCK_STREAM,    1, DONT_WAIT,    discard_stream,
  385.     "discard",    SOCK_DGRAM,    0, DONT_WAIT,    discard_dg,
  386.  
  387.     /* Return 32 bit time since 1970 */
  388.     "time",        SOCK_STREAM,    0, DONT_WAIT,    machtime_stream,
  389.     "time",        SOCK_DGRAM,    0, DONT_WAIT,    machtime_dg,
  390.  
  391.     /* Return human-readable time */
  392.     "daytime",    SOCK_STREAM,    0, DONT_WAIT,    daytime_stream,
  393.     "daytime",    SOCK_DGRAM,    0, DONT_WAIT,    daytime_dg,
  394.  
  395.     /* Familiar character generator */
  396.     "chargen",    SOCK_STREAM,    1, DONT_WAIT,    chargen_stream,
  397.     "chargen",    SOCK_DGRAM,    0, DONT_WAIT,    chargen_dg,
  398.     0
  399. };
  400.  
  401. /* Internal buffer size. Allocated from stack */
  402. #define    BUFSIZE    8192
  403.  
  404. #define NUMINT    (sizeof(intab) / sizeof(struct inent))
  405.  
  406. int debug;
  407. char *CONFIG = _PATH_INETDCONF;
  408.  
  409. main(void)
  410. {
  411.   register struct servtab *sep;
  412.   ULONG events;
  413.   ULONG mask;
  414.  
  415.   {
  416.     LONG Argv[2];
  417.     struct RDArgs *rdargs;
  418.  
  419.     Argv[0] = Argv[1] = 0;
  420.     rdargs = ReadArgs("DEBUG/S,CONFIGFILE", Argv, NULL);
  421.  
  422.     if (!rdargs) {
  423.       PrintFault(IoErr(), "ReadArgs");
  424.       exit(1);
  425.     }
  426.     debug = Argv[0];
  427.     if (Argv[1])
  428.       CONFIG = strdup((char *)Argv[1]);
  429.  
  430.     FreeArgs(rdargs);
  431.   }
  432.  
  433.   if (debug) {
  434.     options |= SO_DEBUG;
  435.   } else {
  436. #if 0
  437.     daemon(0, 0);
  438. #endif
  439.   }
  440.  
  441.   openlog("inetd", LOG_PID | LOG_NOWAIT, LOG_DAEMON);
  442.  
  443.   amigainit();
  444.  
  445.   events = 1 << (dport->dp_Port.mp_SigBit) | 1 << (tport->mp_SigBit) 
  446.     | SIGBREAKF_CTRL_F | SIGBREAKF_CTRL_C;
  447.   SetSocketSignals(0L, 0L, 0L); /* no no no no no no there is no EINTR */
  448.  
  449.   config();
  450.  
  451.   for (;;) {
  452.     int n, ctrl;
  453.     fd_set readable;
  454.  
  455.     mask = events;
  456.     readable = allsock;
  457.     if ((n = WaitSelect(maxsock + 1, &readable, (fd_set *)NULL,
  458.             (fd_set *)NULL, (struct timeval *)NULL, &mask)) < 0) {
  459.       if (errno != EINTR)
  460.     syslog(LOG_WARNING, "select: %s", strerror(errno));
  461.       continue;
  462.     }
  463.  
  464.     if (mask & SIGBREAKF_CTRL_F) {
  465.       config();
  466.     }
  467.  
  468.     if (mask & SIGBREAKF_CTRL_C) {
  469.       exit(0);
  470.     }
  471.  
  472.     if (mask & (1<<(tport->mp_SigBit))) {
  473.       getalarm();
  474.     }
  475.  
  476.     if (mask & (1<<(dport->dp_Port.mp_SigBit))) {
  477.       reapchild();
  478.     }
  479.  
  480.     for (sep = servtab; n && sep; sep = sep->se_next)
  481.       if (sep->se_fd != -1 && FD_ISSET(sep->se_fd, &readable)) {
  482.     n--;
  483.     if (debug)
  484.       fprintf(stderr, "someone wants %s\n", sep->se_service);
  485.     if (sep->se_socktype == SOCK_STREAM) {
  486.       ctrl = accept(sep->se_fd, NULL, NULL);
  487.       if (debug)
  488.         fprintf(stderr, "accept, ctrl %ld\n", ctrl);
  489.       if (ctrl < 0) {
  490.         if (errno != EINTR)
  491.           syslog(LOG_WARNING, "accept (for %s): %s", 
  492.              sep->se_service, strerror(errno));
  493.         continue;
  494.       }
  495.     } else
  496.       ctrl = sep->se_fd;
  497.     if (sep->se_bi == 0 || sep->se_bi->bi_process) {
  498.       startserver(sep, ctrl);
  499.     } else {
  500.       (*sep->se_bi->bi_fn)(SocketBase, ctrl, sep);
  501.       if (sep->se_socktype == SOCK_STREAM)
  502.         CloseSocket(ctrl);
  503.     }
  504.       }
  505.   }
  506. }
  507.  
  508. /*
  509.  * startserver:
  510.  *      Launch a new process to handle service
  511.  */
  512. void 
  513. startserver( register struct servtab *sep, long ctrl)
  514. {
  515.   LONG id;
  516.   struct DaemonMessage *dm = CreateIORequest(dport, sizeof(*dm));
  517.   UBYTE *dname = proctitle(sep->se_service, ctrl);
  518.   int ok = 0;
  519.  
  520.   if (!dm || !dname) { 
  521.     syslog(LOG_ERR, "inetd exhausted memory, exits");
  522.     if (dm) DeleteIORequest(dm);
  523.     if (dname) FreeVec(dname);
  524.     exit(1);
  525.   }
  526.  
  527.   if (sep->se_count++ == 0) {
  528.     (void)gettimeofday(&sep->se_time, (struct timezone *)0);
  529.   } else if (sep->se_count >= TOOMANY) {
  530.     struct timeval now;
  531.     (void)gettimeofday(&now, (struct timezone *)0);
  532.     if (now.tv_sec - sep->se_time.tv_sec > CNT_INTVL) {
  533.       sep->se_time = now;
  534.       sep->se_count = 1;
  535.     } else {
  536.       syslog(LOG_ERR, "%s/%s server failing (looping), "
  537.          "service terminated\n", sep->se_service, sep->se_proto);
  538.       FD_CLR(sep->se_fd, &allsock);
  539.       (void) CloseSocket(sep->se_fd);
  540.       sep->se_fd = -1;
  541.       sep->se_count = 0;
  542.       nsock--;
  543.       askalarm(RETRYTIME);
  544.     }
  545.   }
  546.  
  547.   if (sep->se_socktype == SOCK_STREAM)
  548.     id = ReleaseSocket(ctrl, -1);
  549.   else
  550.     id = ReleaseCopyOfSocket(ctrl, -1);
  551.  
  552.   if (dm != NULL && id != -1) {
  553.     dm->dm_Msg.mn_Node.ln_Name = dname;
  554.     dm->dm_Id = id;
  555.     dm->dm_Family = AF_INET;
  556.     dm->dm_Type = sep->se_socktype;
  557.  
  558.     if (sep->se_bi) {
  559.       struct Process *pid = NULL;
  560.       /* 
  561.        * Start a built in function
  562.        */
  563.       dm->dm_Retval = (LONG)sep;
  564.       dm->dm_Type = DMTYPE_INTERNAL;
  565.       if (builtins_started < MAX_BUILTIN_PROC) {
  566.     pid =
  567.       CreateNewProcTags(NP_Entry, start_builtin, NP_StackSize, BUFSIZE*2,
  568.                 NP_ExitCode, exitcode, NP_ExitData, dm,
  569.                 NP_Priority, -10,
  570.                 dname ? NP_Name : TAG_DONE, dname,
  571.                 TAG_DONE);
  572.     ok = pid != NULL;
  573.     if (ok) {
  574.       dm->dm_Pid = pid; 
  575.       ptable[builtins_started++] = (long)pid;
  576.     }
  577.       }
  578.     } else {
  579.       /*
  580.        * Start an external process
  581.        */
  582.       BPTR input = Open("NIL:", MODE_OLDFILE);
  583.       BPTR output = Open("NIL:", MODE_OLDFILE);
  584. #if 1
  585.       BPTR seglist;
  586.       struct Segment *sl;
  587.  
  588.       /* Try to find seglist from resident list */
  589.       Forbid();
  590.       if (sl = FindSegment(sep->se_server, NULL, FALSE)) {
  591.     if (sl->seg_UC >= 0) {
  592.       sl->seg_UC++;
  593.       dm->dm_Seg = sl;        /* must be freed */
  594.     } else if (sl->seg_UC != -2) {
  595.       sl = NULL;
  596.     }
  597.       }
  598.       Permit();
  599.  
  600.       if (sl)
  601.     seglist = sl->seg_Seg;
  602.       else
  603.     seglist = NewLoadSegTags(sep->se_server, TAG_DONE);
  604.  
  605.       if (input && output && seglist) {
  606.     ok = (int)
  607.       CreateNewProcTags(NP_Seglist, seglist,
  608.                 NP_FreeSeglist, sl == NULL,
  609.                 NP_Cli, TRUE, 
  610.                 NP_CommandName, sep->se_argv0,
  611.                 NP_Arguments, sep->se_argv, 
  612.                 NP_Input, input, 
  613.                 NP_Output, output,
  614.                 NP_StackSize, BUFSIZE*2, 
  615.                 NP_Priority, -10, 
  616.                 NP_ExitCode, dport->dp_ExitCode,
  617.                 NP_ExitData, dm, 
  618.                 dname ? NP_Name : TAG_END, dname,
  619.                 TAG_END, NULL);
  620.       }
  621.       if (!ok) {
  622.     if (seglist) UnLoadSeg(seglist);
  623.     if (input) Close(input);
  624.     if (output) Close(output);
  625.       }
  626.     }
  627. #else
  628.       if (input && output) {
  629.     ok = !SystemTags(sep->se_argv,
  630.              SYS_Asynch, 1, SYS_UserShell, 1,
  631.              SYS_Input, input, SYS_Output, output,
  632.              NP_StackSize, BUFSIZE*2,
  633.              NP_ExitCode, exitcode, NP_ExitData, dm,
  634.              NP_Priority, -10, 
  635.              dname ? NP_Name : TAG_END, dname,
  636.              TAG_END, NULL);
  637.       }
  638.       if (!ok) {
  639.     if (input) Close(input);
  640.     if (output) Close(output);
  641.       }
  642.     }
  643. #endif
  644.     if (ok && sep->se_wait) {
  645.       sep->se_wait = dm;
  646.       if (sep->se_fd >= 0) {
  647.     FD_CLR(sep->se_fd, &allsock);
  648.     nsock--;
  649.       }
  650.     }
  651.   }
  652.  
  653.   /* Clean up */
  654.   if (!ok) {
  655.     /* Drop the pending datagram */
  656.     char buf[32];
  657.     if (sep->se_socktype != SOCK_STREAM)
  658.       recv(ctrl, buf, sizeof (buf), 0);
  659.  
  660.     if (dm) DeleteIORequest(dm);
  661.     if (dname) FreeVec(dname);
  662.     if (id != -1) {
  663.       ctrl = ObtainSocket(id, AF_INET, sep->se_socktype, 0);
  664.       if (ctrl >= 0) CloseSocket(ctrl);
  665.     }
  666.   }
  667. }
  668.  
  669. /*
  670.  * reapchild: 
  671.  *      handle death messages from childs
  672.  */
  673. void
  674. reapchild(void)
  675. {
  676.   struct DaemonMessage *dm;
  677.  
  678.   while (dm = (struct DaemonMessage *)GetMsg(dport)) {
  679.     long status = dm->dm_Retval;
  680.     register struct servtab *sep;
  681.  
  682.     if (debug)
  683.       fprintf(stderr, "reaped child %s\n", dm->dm_Msg.mn_Node.ln_Name);
  684.     for (sep = servtab; sep; sep = sep->se_next)
  685.       if (sep->se_wait == dm) {
  686.     if (status)
  687.       syslog(LOG_WARNING,
  688.          "%s: exit status 0x%lx",
  689.          sep->se_server, status);
  690.     if (debug)
  691.       fprintf(stderr, "restored %s, fd %ld\n",
  692.           sep->se_service, sep->se_fd);
  693.     FD_SET(sep->se_fd, &allsock);
  694.     nsock++;
  695.     sep->se_wait = DO_WAIT;
  696.       }
  697.  
  698.     /* update "process table" */ 
  699.     if (dm->dm_Type == DMTYPE_INTERNAL) {
  700.       long pid = (long)dm->dm_Pid;
  701.       int i = --builtins_started;
  702.       for (i; i >= 0; i--) 
  703.     if (pid = ptable[i]) {
  704.       ptable[i] = ptable[builtins_started];
  705.       break;
  706.     }
  707.       if (i < 0) {
  708.     syslog(LOG_ALERT, "inetd: unknown internal daemon 0x%lx", pid);
  709.     builtins_started++;
  710.       }
  711.     }
  712.     /* Free resources allocated for the daemon */
  713.     if (dm->dm_Seg) {
  714.       Forbid();
  715.       dm->dm_Seg->seg_UC--;
  716.       Permit();
  717.     }
  718.     if (dm->dm_Msg.mn_Node.ln_Name)
  719.       FreeVec(dm->dm_Msg.mn_Node.ln_Name);
  720.     DeleteIORequest(dm);
  721.   }
  722. }
  723.  
  724. /*
  725.  * config:
  726.  *      configure services
  727.  */
  728. void
  729. config(void)
  730. {
  731.   register struct servtab *sep, *cp, **sepp;
  732.  
  733.   if (!setconfig()) {
  734.     endconfig();
  735.     return;
  736.   }
  737.  
  738.   for (sep = servtab; sep; sep = sep->se_next)
  739.     sep->se_checked = 0;
  740.   while (cp = getconfigent()) {
  741.     for (sep = servtab; sep; sep = sep->se_next)
  742.       if (strcmp(sep->se_service, cp->se_service) == 0 &&
  743.       strcmp(sep->se_proto, cp->se_proto) == 0)
  744.     break;
  745.     if (sep != 0) {
  746.       freeconfig(sep);
  747.       /*
  748.        * sep->se_wait may be holding the "pid" of a daemon
  749.        * that we're waiting for.  If so, don't overwrite
  750.        * it unless the config file explicitly says don't 
  751.        * wait.
  752.        */
  753.       if (cp->se_bi == 0 && 
  754.       (sep->se_wait == DO_WAIT || cp->se_wait == DONT_WAIT))
  755.     sep->se_wait  = cp->se_wait;
  756.       sep->se_service = cp->se_service;
  757.       sep->se_proto   = cp->se_proto;
  758.       sep->se_user    = cp->se_user;
  759.       sep->se_server  = cp->se_server;
  760.       sep->se_argv    = cp->se_argv;
  761.       if (debug)
  762.     print_service("REDO", sep);
  763.     } else {
  764.       sep = enter(cp);
  765.       if (debug)
  766.     print_service("ADD ", sep);
  767.     }
  768.     sep->se_checked = 1;
  769.     sp = getservbyname(sep->se_service, sep->se_proto);
  770.     if (sp == 0) {
  771.       syslog(LOG_ERR, "%s/%s: unknown service",
  772.          sep->se_service, sep->se_proto);
  773.       if (sep->se_fd != -1)
  774.     (void) CloseSocket(sep->se_fd);
  775.       sep->se_fd = -1;
  776.       continue;
  777.     }
  778.     if (sp->s_port != sep->se_ctrladdr.sin_port) {
  779.       sep->se_ctrladdr.sin_port = sp->s_port;
  780.       if (sep->se_fd != -1)
  781.     (void) CloseSocket(sep->se_fd);
  782.       sep->se_fd = -1;
  783.     }
  784.     if (sep->se_fd == -1)
  785.       setup(sep);
  786.   }
  787.   endconfig();
  788.   /*
  789.    * Purge anything not looked at above.
  790.    */
  791.   sepp = &servtab;
  792.   while (sep = *sepp) {
  793.     if (sep->se_checked) {
  794.       sepp = &sep->se_next;
  795.       continue;
  796.     }
  797.     *sepp = sep->se_next;
  798.     if (sep->se_fd != -1) {
  799.       FD_CLR(sep->se_fd, &allsock);
  800.       nsock--;
  801.       (void) CloseSocket(sep->se_fd);
  802.     }
  803.     if (debug)
  804.       print_service("FREE", sep);
  805.     freeconfig(sep);
  806.     free((char *)sep);
  807.   }
  808. }
  809.  
  810. /*
  811.  * askalarm:
  812.  *      ask for timeout
  813.  */
  814. void 
  815. askalarm(long seconds) 
  816. {
  817.   if (tmsg->tr_node.io_Message.mn_Node.ln_Type == NT_UNKNOWN 
  818.       || CheckIO(tmsg)) {
  819.     tmsg->tr_time.tv_secs = seconds;
  820.     tmsg->tr_time.tv_micro = 0;
  821.     SendIO(tmsg);
  822.   }
  823. }
  824.  
  825. /*
  826.  * getalarm:
  827.  *      handle timeouts
  828.  */
  829. void 
  830. getalarm(void) 
  831. {
  832.   struct Message *msg;
  833.   while (msg = GetMsg(tport)) {
  834.     if ((struct timerequest *)msg == tmsg) {
  835.       tmsg->tr_node.io_Message.mn_Node.ln_Type = NT_UNKNOWN; 
  836.       retry();
  837.       continue;
  838.     }
  839.   }
  840. }
  841.  
  842. /*
  843.  * retry:
  844.  *      try to setup all configured services
  845.  */
  846. void
  847. retry(void)
  848. {
  849.   register struct servtab *sep;
  850.  
  851.   for (sep = servtab; sep; sep = sep->se_next)
  852.     if (sep->se_fd == -1)
  853.       setup(sep);
  854. }
  855.  
  856. /*
  857.  * setup:
  858.  *      open a socket for given port
  859.  */
  860. void
  861. setup(register struct servtab *sep)
  862. {
  863.   int on = 1;
  864.  
  865.   if ((sep->se_fd = socket(AF_INET, sep->se_socktype, 0)) < 0) {
  866.     syslog(LOG_ERR, "%s/%s: socket: %s",
  867.        sep->se_service, sep->se_proto, strerror(errno));
  868.     return;
  869.   }
  870. #define    turnon(fd, opt) \
  871.   setsockopt(fd, SOL_SOCKET, opt, (char *)&on, sizeof (on))
  872.     if (strcmp(sep->se_proto, "tcp") == 0 && (options & SO_DEBUG) &&
  873.     turnon(sep->se_fd, SO_DEBUG) < 0)
  874.       syslog(LOG_ERR, "setsockopt (SO_DEBUG): %s", strerror(errno));
  875.   if (turnon(sep->se_fd, SO_REUSEADDR) < 0)
  876.     syslog(LOG_ERR, "setsockopt (SO_REUSEADDR): %s", strerror(errno));
  877. #undef turnon
  878.   if (bind(sep->se_fd, (struct sockaddr *)&sep->se_ctrladdr,
  879.        sizeof (sep->se_ctrladdr)) < 0) {
  880.     syslog(LOG_ERR, "%s/%s: bind: %s",
  881.        sep->se_service, sep->se_proto, strerror(errno));
  882.     (void) CloseSocket(sep->se_fd);
  883.     sep->se_fd = -1;
  884.     askalarm(RETRYTIME);
  885.     return;
  886.   }
  887.   if (sep->se_socktype == SOCK_STREAM)
  888.     listen(sep->se_fd, 10);
  889.   FD_SET(sep->se_fd, &allsock);
  890.   nsock++;
  891.   if (sep->se_fd > maxsock)
  892.     maxsock = sep->se_fd;
  893. }
  894.  
  895. /*
  896.  * enter:
  897.  *      Allocate a new server entry
  898.  */ 
  899. struct servtab *
  900. enter(struct servtab *cp)
  901. {
  902.   register struct servtab *sep;
  903.  
  904.   sep = (struct servtab *)malloc(sizeof (*sep));
  905.   if (sep == (struct servtab *)0) {
  906.     syslog(LOG_ERR, "Out of memory.");
  907.     exit(20);
  908.   }
  909.   *sep = *cp;
  910.   sep->se_fd = -1;
  911.   sep->se_next = servtab;
  912.   servtab = sep;
  913.  
  914.   return (sep);
  915. }
  916.  
  917. /*
  918.  * print_service:
  919.  *    Dump relevant information to stderr
  920.  */
  921. void
  922. print_service(char *action, struct servtab *sep)
  923. {
  924.   fprintf(stderr, "%s: %s proto=%s, "
  925.       "wait=%ld, user=%s builtin=0x%lx server=%s\n",
  926.       action, sep->se_service, sep->se_proto,
  927.       sep->se_wait, sep->se_user, (int)sep->se_bi, sep->se_server);
  928. }
  929.  
  930.  
  931. /* 
  932.  * Functions to read configuration file
  933.  */
  934.  
  935. BPTR    fconfig = NULL;
  936. long    linecnt = 0;
  937. struct    servtab serv;
  938. #define LINEBUFLEN 1024
  939. char    *linbuf = NULL;
  940. struct  CSource    line = { 0, 0, 0 };
  941. struct RDArgs *largs = NULL;
  942.  
  943. void logdoserror(const char *banner);
  944. struct CSource * nextline(BPTR fh);
  945.  
  946. int
  947. setconfig(void)
  948. {
  949.   linecnt = 0;
  950.  
  951.   if (!linbuf) 
  952.     linbuf = malloc(LINEBUFLEN);
  953.  
  954.   if (!largs) 
  955.     largs = AllocDosObject(DOS_RDARGS, NULL);
  956.  
  957.   if (fconfig != NULL) {
  958.     Seek(fconfig, 0L, OFFSET_BEGINNING);
  959.   } else {
  960.     fconfig = Open(CONFIG, MODE_OLDFILE);
  961.     if (!fconfig) logdoserror("setconfig");
  962.   }
  963.   return (fconfig != NULL && linbuf != NULL && largs != NULL);
  964. }
  965.  
  966. void
  967. endconfig(void)
  968. {
  969.   if (fconfig) {
  970.     (void) Close(fconfig);
  971.     fconfig = NULL;
  972.   }
  973. #if 0
  974.   if (linbuf) {
  975.     free(linbuf);
  976.     linbuf = NULL;
  977.   }
  978. #endif
  979.   if (largs) {
  980.     FreeDosObject(DOS_RDARGS, largs);
  981.     largs = NULL;
  982.   }
  983. }
  984.  
  985. struct servtab *
  986. getconfigent(void)
  987. {
  988.   register struct servtab *sep = &serv;
  989.   struct CSource *cp;
  990.  
  991.  more:
  992.   while ((cp = nextline(fconfig)) && 
  993.      (cp->CS_Buffer[0] == '#' || cp->CS_Buffer[0] == ';'))
  994.     ;
  995.   if (cp == NULL)
  996.     return NULL;
  997.  
  998.   {
  999.     short len, i, item;
  1000.     char *old, *new; 
  1001.     UBYTE *argv[MAXARGS];
  1002.     UBYTE argbuf[LINEBUFLEN];
  1003.  
  1004.     /* Parse line */
  1005.     for (len = i = 0; i < MAXARGS - 1; i++) {
  1006.       argv[i] = argbuf + len;
  1007.       item = (short)ReadItem(argbuf + len, sizeof(argbuf) - len, cp);
  1008.       if (item < 0) {
  1009.     logdoserror("ReadItem");
  1010.     return NULL;
  1011.       } else if (item == ITEM_NOTHING) {
  1012.     for (; i < MAXARGS - 1; i++) {
  1013.       argv[i] = " ";
  1014.       len += 2;
  1015.     }
  1016.     break;
  1017.       } else {
  1018.     len += strlen(argv[i]) + 1;
  1019.       }
  1020.     }
  1021.     if (i == MAXARGS - 1) { /* arguments to the server */
  1022.       argv[i] = cp->CS_Buffer + cp->CS_CurChr;
  1023.       len += strlen(argv[i]) + 1;
  1024.     }
  1025.  
  1026.     sep->se_socktype = FindArg(TYPETEMPLATE, (STRPTR)argv[socket_type]) + 1;
  1027.     if (sep->se_socktype == 0) 
  1028.       sep->se_socktype = DMTYPE_UNKNOWN;
  1029.  
  1030.     switch (FindArg(WAITTEMPLATE, (STRPTR)argv[wait])) {
  1031.     case -1:
  1032.       /* A error message might be cool */
  1033.     case 0:
  1034.       sep->se_wait = DONT_WAIT;
  1035.       break;
  1036.     case 1:
  1037.       sep->se_wait = DO_WAIT;
  1038.       break;
  1039.     }
  1040.  
  1041.     new = malloc(len);
  1042.     if (!new) {
  1043.       SetIoErr(ERROR_NO_FREE_STORE);
  1044.       logdoserror("getconfigent");
  1045.       return NULL;
  1046.     }
  1047.  
  1048.     sep->se_service = new; 
  1049.     old = (char *)argv[service]; while (*new++ = *old++); 
  1050.     sep->se_proto = new;
  1051.     old = (char *)argv[protocol]; while (*new++ = *old++); 
  1052.     sep->se_user = new;
  1053.     old = (char *)argv[user]; while (*new++ = *old++); 
  1054.     sep->se_server = new;
  1055.     old = (char *)argv[server]; while (*new++ = *old++); 
  1056.     sep->se_argv0 = new;
  1057.     old = (char *)argv[cmdname]; while (*new++ = *old++); 
  1058.     sep->se_argv = new;
  1059.     old = (char *)argv[arguments]; while (*new++ = *old++); 
  1060.   }
  1061.   
  1062.   if (strcmp(sep->se_server, "internal") == 0) {
  1063.     register struct biltin *bi;
  1064.  
  1065.     for (bi = biltins; bi->bi_service; bi++)
  1066.       if (bi->bi_socktype == sep->se_socktype &&
  1067.       strcmp(bi->bi_service, sep->se_service) == 0)
  1068.     break;
  1069.     if (bi->bi_service == 0) {
  1070.       syslog(LOG_ERR, "inetd: internal service %s unknown\n", sep->se_service);
  1071.       free(sep->se_service);
  1072.       goto more;
  1073.     }
  1074.     sep->se_bi = bi;
  1075.     sep->se_wait = bi->bi_wait;
  1076.   } else
  1077.     sep->se_bi = NULL;
  1078.  
  1079.   return (sep);
  1080. }
  1081.  
  1082. void
  1083. freeconfig(register struct servtab *cp)
  1084. {
  1085.   if (cp->se_service)
  1086.     free(cp->se_service);
  1087. }
  1088.  
  1089. /*
  1090.  * nextline
  1091.  *      get a CSource string containing next line
  1092.  */
  1093. struct CSource *
  1094. nextline(BPTR fh)
  1095. {
  1096.   size_t len = line.CS_Length = 0;
  1097.   UBYTE *buffer = line.CS_Buffer = linbuf;
  1098.   
  1099.   line.CS_CurChr = 0;
  1100.   
  1101.   for (;;) {
  1102.     linecnt++;
  1103.     if (FGets(fh, buffer + len, LINEBUFLEN - len - 1) == NULL) {
  1104.       if (IoErr()) {
  1105.     logdoserror("nextline");
  1106.     return NULL;
  1107.       }
  1108.       if (len == 0)
  1109.     return NULL;
  1110.     }
  1111.  
  1112.     len += strlen(buffer + len);
  1113.  
  1114.     /* a long line ? */
  1115.     if (len == LINEBUFLEN - 1 && buffer[LINEBUFLEN - 2] != '\n') {
  1116.       if (buffer[0] != '#') {
  1117.     SetIoErr(ERROR_LINE_TOO_LONG);
  1118.     logdoserror("nextline");
  1119.     return NULL;
  1120.       } else {
  1121.     /* A kludge for LONG comment lines */
  1122.     len = 1;
  1123.     linecnt--;
  1124.     continue;
  1125.       }
  1126.     }
  1127.  
  1128.     /* Check for a continued line */
  1129.     if (len > 1 && buffer[len - 2] != '+') {
  1130.       break;
  1131.     } else {
  1132.       /* current line continues */
  1133.       if (len > 2)
  1134.     len -= 2;
  1135.       else 
  1136.     len = 0;
  1137.     }
  1138.   }
  1139.   
  1140.   /*
  1141.    * Ensure that the line ends with '\n'.
  1142.    * This is required by AmigaDOS parsing functions.
  1143.    * There must be space for the newline, if there wouldn't,
  1144.    * the "long line" would have been caught above.
  1145.    */
  1146.   if (buffer[len - 1] != '\n') {
  1147.     buffer[len++] = '\n';
  1148.     buffer[len] = 0;
  1149.   }
  1150.   
  1151.   line.CS_Length = len;
  1152.   return &line;
  1153. }
  1154.  
  1155. /* 
  1156.  * logdoserror
  1157.  *     add the last DOS error into AmiTCP/IP log
  1158.  */
  1159. void 
  1160. logdoserror(const char *banner)
  1161. {
  1162.   LONG code = IoErr();
  1163.  
  1164.   if (linbuf && Fault(code, (UBYTE *)banner, linbuf, LINEBUFLEN)) {
  1165.     syslog(LOG_ERR, "inetd %s at line %ld\n", linbuf, linecnt);
  1166.   } else {
  1167.     syslog(LOG_ERR, "inetd %s: unknown DOS error %ld at line %ld\n", 
  1168.        code, linecnt);
  1169.   }
  1170. }
  1171.  
  1172.  
  1173. /*
  1174.  * Internet services provided internally by inetd:
  1175.  */
  1176.  
  1177. /* Echo service -- echo data back */
  1178. int
  1179. echo_stream(void *SocketBase, int s, struct servtab *sep)
  1180. {
  1181.   char buffer[BUFSIZE];
  1182.   int i;
  1183.  
  1184.   while ((i = recv(s, buffer, sizeof(buffer), 0)) > 0 &&
  1185.      send(s, buffer, i, 0) > 0)
  1186.     ;
  1187.   return 0;
  1188. }
  1189.  
  1190. /* Echo service -- echo data back */
  1191. int
  1192. echo_dg(void *SocketBase, int s, struct servtab *sep)
  1193. {
  1194.   char buffer[BUFSIZE];
  1195.   long i, size;
  1196.   struct sockaddr sa;
  1197.  
  1198.   size = sizeof(sa);
  1199.   if ((i = recvfrom(s, buffer, sizeof(buffer), 0, &sa, &size)) < 0)
  1200.     return 0;
  1201.   (void) sendto(s, buffer, i, 0, &sa, sizeof(sa));
  1202.  
  1203.   return 0;
  1204. }
  1205.  
  1206. /* Discard service -- ignore data */
  1207. int
  1208. discard_stream(void *SocketBase, int s, struct servtab *sep)
  1209. {
  1210.   char buffer[BUFSIZE];
  1211.  
  1212.   while (recv(s, buffer, sizeof(buffer), 0) > 0)
  1213.     ;
  1214.  
  1215.   return 0;
  1216. }
  1217.  
  1218.  
  1219. /* Discard service -- ignore data */
  1220. int
  1221. discard_dg(void *SocketBase, int s, struct servtab *sep)
  1222. {
  1223.   char buffer[BUFSIZE];
  1224.  
  1225.   (void) recv(s, buffer, sizeof(buffer), 0);
  1226.   
  1227.   return 0;
  1228. }
  1229.  
  1230. #include <ctype.h>
  1231. #define LINESIZ 72
  1232. char ring[128];
  1233. char *endring = NULL;
  1234.  
  1235. void
  1236. initring(void)
  1237. {
  1238.   register int i;
  1239.  
  1240.   endring = ring;
  1241.  
  1242.   for (i = 0; i <= 128; ++i)
  1243.     if (isprint(i))
  1244.       *endring++ = i;
  1245. }
  1246.  
  1247. /* Character generator */
  1248. chargen_stream(void *SocketBase, int s, struct servtab *sep)
  1249. {
  1250.   register char *rs;
  1251.   long len;
  1252.   char text[LINESIZ+2];
  1253.  
  1254.   if (!endring) {
  1255.     initring();
  1256.   }
  1257.  
  1258.   text[LINESIZ] = '\r';
  1259.   text[LINESIZ + 1] = '\n';
  1260.   for (rs = ring;;) {
  1261.     if ((len = endring - rs) >= LINESIZ)
  1262.       bcopy(rs, text, LINESIZ);
  1263.     else {
  1264.       bcopy(rs, text, len);
  1265.       bcopy(ring, text + len, LINESIZ - len);
  1266.     }
  1267.     if (++rs == endring)
  1268.       rs = ring;
  1269.     if (send(s, text, sizeof(text), 0) != sizeof(text))
  1270.       break;
  1271.   }
  1272.  
  1273.   return 0;
  1274. }
  1275.  
  1276. /* Character generator */
  1277. chargen_dg(void *SocketBase, int s, struct servtab *sep)
  1278. {
  1279.   struct sockaddr sa;
  1280.   static char *rs;
  1281.   long len, size;
  1282.   char text[LINESIZ+2];
  1283.  
  1284.   if (endring == 0) {
  1285.     initring();
  1286.     rs = ring;
  1287.   }
  1288.  
  1289.   size = sizeof(sa);
  1290.   if (recvfrom(s, text, sizeof(text), 0, &sa, &size) < 0)
  1291.     return 0;
  1292.  
  1293.   if ((len = endring - rs) >= LINESIZ)
  1294.     bcopy(rs, text, LINESIZ);
  1295.   else {
  1296.     bcopy(rs, text, len);
  1297.     bcopy(ring, text + len, LINESIZ - len);
  1298.   }
  1299.   if (++rs == endring)
  1300.     rs = ring;
  1301.   text[LINESIZ] = '\r';
  1302.   text[LINESIZ + 1] = '\n';
  1303.   (void) sendto(s, text, sizeof(text), 0, &sa, sizeof(sa));
  1304.  
  1305.   return 0;
  1306. }
  1307.  
  1308. /*
  1309.  * Return a machine readable date and time, in the form of the
  1310.  * number of seconds since midnight, Jan 1, 1900.  Since gettimeofday
  1311.  * returns the number of seconds since midnight, Jan 1, 1970,
  1312.  * we must add 2208988800 seconds to this figure to make up for
  1313.  * some seventy years Bell Labs was asleep.
  1314.  */
  1315.  
  1316. long
  1317. machtime(void)
  1318. {
  1319.   struct timeval tv;
  1320.  
  1321.   if (gettimeofday(&tv, (struct timezone *)0) < 0) {
  1322.     /* fprintf(stderr, "Unable to get time of day\n"); */
  1323.     return (0L);
  1324.   }
  1325.   return (long)(htonl((long)tv.tv_sec + 2208988800));
  1326. }
  1327.  
  1328. int 
  1329. machtime_stream(void *SocketBase, int s, struct servtab *sep)
  1330. {
  1331.   long result;
  1332.  
  1333.   result = machtime();
  1334.   (void) send(s, (char *) &result, sizeof(result), 0);
  1335.  
  1336.   return 0;
  1337. }
  1338.  
  1339. machtime_dg(void *SocketBase, int s, struct servtab *sep)
  1340. {
  1341.   long result;
  1342.   struct sockaddr sa;
  1343.   long size;
  1344.  
  1345.   size = sizeof(sa);
  1346.   if (recvfrom(s, (char *)&result, sizeof(result), 0, &sa, &size) < 0)
  1347.     return 0;
  1348.   result = machtime();
  1349.   (void) sendto(s, (char *) &result, sizeof(result), 0, &sa, sizeof(sa));
  1350.  
  1351.   return 0;
  1352. }
  1353.  
  1354. /* Return human-readable time of day */
  1355. int
  1356. daytime_stream(void *SocketBase, int s, struct servtab *sep)
  1357. {
  1358.   char buffer[256];
  1359.   time_t time(), clock;
  1360.   char *ctime();
  1361.   
  1362.   clock = time((time_t *) 0);
  1363.   
  1364.   (void) strncpy(buffer, ctime(&clock), 24);   buffer[24] = '\0';
  1365.   (void) strcat(buffer, "\r\n");
  1366.   (void) send(s, buffer, strlen(buffer), 0);
  1367.   return 0;
  1368. }
  1369.  
  1370. /* Return human-readable time of day */
  1371. int
  1372. daytime_dg(void *SocketBase, int s, struct servtab *sep)
  1373. {
  1374.   char buffer[256];
  1375.   time_t time(), clock;
  1376.   struct sockaddr sa;
  1377.   long size;
  1378.  
  1379.   clock = time((time_t *) 0);
  1380.  
  1381.   size = sizeof(sa);
  1382.   if (recvfrom(s, buffer, sizeof(buffer), 0, &sa, &size) < 0)
  1383.     return 0;
  1384.  
  1385.   (void) strncpy(buffer, ctime(&clock), 24);   buffer[24] = '\0';
  1386.   (void) strcat(buffer, "\r\n");
  1387.   (void) sendto(s, buffer, strlen(buffer), 0, &sa, sizeof(sa));
  1388.   return 0;
  1389. }
  1390.  
  1391. /*
  1392.  * Internal server stub 
  1393.  */
  1394. LONG SAVEDS start_builtin(void)
  1395. {
  1396.   struct Process *me = (struct Process *)FindTask(0L);
  1397.   struct DaemonMessage *dm = (struct DaemonMessage *)me->pr_ExitData;
  1398.   LONG retval = DERR_LIB; 
  1399.   void *SocketBase;
  1400.  
  1401.   if (SocketBase = OpenLibrary("bsdsocket.library", 2L)) {
  1402.     struct servtab *sep = (struct servtab *)dm->dm_Retval;
  1403.     int s = ObtainSocket(dm->dm_Id, AF_INET, sep->se_socktype, 0);
  1404.     if (s != -1) {
  1405.       dm->dm_Id = -1;
  1406.       retval = (*sep->se_bi->bi_fn)(SocketBase, s, sep);
  1407.     } else {
  1408.       retval = DERR_OBTAIN;
  1409.     }
  1410.     CloseLibrary(SocketBase);
  1411.   } 
  1412.  
  1413.   return retval;
  1414. }
  1415.  
  1416. /* 
  1417.  * setproctitle:
  1418.  *      set the process title
  1419.  */
  1420. void
  1421. setproctitle(char *a, int s)
  1422. {
  1423. #ifdef notyet
  1424.   int size;
  1425.   register char *cp;
  1426.   struct sockaddr_in sin;
  1427.   char buf[80];
  1428.   struct CSource csbuf;
  1429.   
  1430.   csbuf.CS_Buffer = buf;
  1431.   csbuf.CS_Length = sizeof(buf) - 1;
  1432.   csbuf.CS_CurChr = 0;
  1433.  
  1434.   size = sizeof(sin);
  1435.   if (getpeername(s, (struct sockaddr *)&sin, &size) == 0) {
  1436.     struct MemList ml, *nml;
  1437.  
  1438.     (void) csprintf(csbuf, "%s [%s]", a, inet_ntoa(sin.sin_addr)); 
  1439.  
  1440.     ml.ml_NumEntries = 1;
  1441.     ml.ml_ME[0].me_Reqs = MEMF_PUBLIC;
  1442.     ml.ml_ME[0].me_Length = csbuf.CS_CurChr + 1;
  1443.  
  1444.     /* A memlist entry is needed for automatic resource deallocation */
  1445.     if ((LONG)(nml = AllocEntry(&ml)) > 0) {
  1446.       struct Task *me = FindTask(NULL);
  1447.  
  1448.       cp = nml->ml_ME[1].me_Addr;
  1449.       buf[csbuf.CS_CurChr] = '\0';
  1450.       strcpy(cp, buf);
  1451.  
  1452.       /* Old name is pointer to se_service, so there is no need to free it */
  1453.       me->tc_Node.ln_Name = cp;
  1454.       Forbid();
  1455.       AddHead(&me->tc_MemEntry, nml);
  1456.       Permit();
  1457.     }
  1458.   }
  1459. #endif
  1460. }
  1461.  
  1462. /* 
  1463.  * proctitle:
  1464.  *     allocate a new process title 
  1465.  */
  1466. UBYTE *
  1467. proctitle(char *a, int s)
  1468. {
  1469.   long size;
  1470.   struct sockaddr_in sin;
  1471.   register char *cp;
  1472.   char buf[80];
  1473.   struct CSource csbuf;
  1474.   
  1475.   csbuf.CS_Buffer = buf;
  1476.   csbuf.CS_Length = sizeof(buf) - 1;
  1477.   csbuf.CS_CurChr = 0;
  1478.  
  1479.   size = sizeof(sin);
  1480.   if (getpeername(s, (struct sockaddr *)&sin, &size) == 0) {
  1481.     (void) csprintf(&csbuf, "%s [%s]", a, inet_ntoa(sin.sin_addr)); 
  1482.   } else {
  1483.     (void) csprintf(&csbuf, "%s", a); 
  1484.   }
  1485.   if (cp = AllocVec(csbuf.CS_CurChr + 1, MEMF_PUBLIC)) {
  1486.     buf[csbuf.CS_CurChr] = '\0';
  1487.     strcpy(cp, buf);
  1488.   }
  1489.   return cp;
  1490. }
  1491.  
  1492. #if __SASC
  1493. #define SysBase (*(struct ExecBase**)4)
  1494. /* 
  1495.  * Amiga process catcher
  1496.  */
  1497. ASM LONG
  1498. exitcode(REG(d0) LONG status, REG(d1) LONG exitmessage)
  1499. {
  1500.   ((struct DaemonMessage *)exitmessage)->dm_Retval = status;
  1501.   ReplyMsg((struct Message *)exitmessage);
  1502.   return 0;
  1503. }
  1504.  
  1505. void
  1506. exitcode_end(void)
  1507. {
  1508. }
  1509. #undef SysBase
  1510.  
  1511. #define exitcode_len (((char *)exitcode_end)-((char *)exitcode))
  1512. #else
  1513. #error Unsupported compiler
  1514. #endif
  1515.  
  1516. void *WindowPtr = NULL;
  1517.  
  1518. /* 
  1519.  * Initialize Amiga Specific Features
  1520.  */
  1521. void 
  1522. amigainit(void)
  1523. {
  1524.   struct DaemonPort *dp, *dpo;
  1525.   BYTE msgbit;
  1526.   struct Process *me = (struct Process *)FindTask(NULL);
  1527.   int old_is_alive = 0;
  1528.  
  1529.   atexit(amigadeinit);
  1530.  
  1531.   /* Remove requesters */
  1532.   WindowPtr = me->pr_WindowPtr;
  1533.   me->pr_WindowPtr = (void *)-1L;
  1534.  
  1535.   if ((msgbit = AllocSignal(-1)) == -1) {
  1536.     (void)fprintf(stderr, "inetd: no free signals\n");
  1537.     exit(2);
  1538.   }
  1539.  
  1540.   /* Allocate a global port for DaemonMessages */
  1541.   if (dp = AllocVec(sizeof(*dp) + exitcode_len + sizeof(DAEMONPORTNAME),
  1542.             MEMF_CLEAR|MEMF_PUBLIC)) {
  1543.     dp->dp_Port.mp_Node.ln_Type = NT_MSGPORT;
  1544.     dp->dp_Port.mp_SigTask = me;
  1545.     dp->dp_Port.mp_Flags = PA_SIGNAL;
  1546.     dp->dp_Port.mp_SigBit = msgbit;
  1547.     memcpy(dp->dp_ExitCode = (char *)(dp + 1), exitcode, exitcode_len);
  1548.     memcpy(dp->dp_Port.mp_Node.ln_Name = exitcode_len + (UBYTE *)(dp + 1),
  1549.        DAEMONPORTNAME, sizeof(DAEMONPORTNAME));
  1550.     /* Flush copied function */
  1551.     CacheClearE(dp->dp_ExitCode, exitcode_len, CACRF_ClearI);
  1552.   }
  1553.  
  1554.   Forbid();
  1555.  
  1556.   dpo = (struct DaemonPort*)FindPort(DAEMONPORTNAME);
  1557.   if (!dpo) {
  1558.     if (dp) AddPort(dp);
  1559.   } else {
  1560.     FreeVec(dp);
  1561.     dp = dpo;
  1562.     if (dpo->dp_Port.mp_SigTask == NULL) {
  1563.       dpo->dp_Port.mp_SigTask = me;
  1564.       dpo->dp_Port.mp_SigBit = msgbit;
  1565.       dpo->dp_Port.mp_Flags = PA_SIGNAL;
  1566.       SetSignal(1 << msgbit, 1 << msgbit); /* check old messages */
  1567.     } else {
  1568.       old_is_alive = 1;
  1569.     }
  1570.   }
  1571.   Permit();
  1572.  
  1573.   if (old_is_alive || !dp) {
  1574.     FreeSignal(msgbit);
  1575.     (void)fprintf(stderr, old_is_alive ? 
  1576.           "inetd: already exists\n" :
  1577.           "inetd: memory exhausted\n");
  1578.     exit(2);
  1579.   }
  1580.  
  1581.   dport = dp;
  1582.  
  1583.   if (!(tport = CreateMsgPort())) {
  1584.     (void)fprintf(stderr, "inetd: could not create message port\n");
  1585.     exit(2);
  1586.   }
  1587.   if (!(tmsg = CreateIORequest(tport, sizeof(*tmsg)))){
  1588.     (void)fprintf(stderr, "inetd: could not create timer message\n");
  1589.     exit(2);
  1590.   }
  1591.  
  1592.   tmsg->tr_node.io_Message.mn_Node.ln_Type = NT_UNKNOWN; 
  1593.   tmsg->tr_node.io_Command = TR_ADDREQUEST;
  1594.  
  1595.   if (OpenDevice(TIMERNAME, UNIT_MICROHZ, 
  1596.          (struct IORequest *)tmsg, 0)) {
  1597.     (void)fprintf(stderr, "inetd: could not open %s\n", TIMERNAME);
  1598.     exit(2);
  1599.   }
  1600.   timer_is_open = 1;
  1601. }
  1602.  
  1603. /* 
  1604.  * Deinitialize Amiga Specific stuff
  1605.  */
  1606. void
  1607. amigadeinit(void)
  1608. {
  1609.   struct Process *me = (struct Process *)FindTask(NULL);
  1610.  
  1611.   /* Resume requesters for this process */
  1612.   me->pr_WindowPtr = WindowPtr;
  1613.  
  1614.   if (tmsg && timer_is_open) {
  1615.     if (tmsg->tr_node.io_Message.mn_Node.ln_Type != NT_UNKNOWN 
  1616.     && !CheckIO(tmsg)) {
  1617.       AbortIO(tmsg);
  1618.       WaitIO(tmsg);
  1619.     }
  1620.   }
  1621.   if (timer_is_open) {
  1622.     CloseDevice(tmsg);
  1623.     timer_is_open = 0;
  1624.   }
  1625.   if (tmsg) {
  1626.     DeleteIORequest(tmsg);
  1627.   }
  1628.   if (tport) {
  1629.     DeleteMsgPort(tport);
  1630.   }
  1631.  
  1632.   if (dport) {
  1633.     BYTE sigbit;
  1634.     int i;
  1635.  
  1636.     /* Try to kill all our builtin children */
  1637.     for (i = builtins_started - 1; i >= 0; i--)
  1638.       Signal((struct Task*)ptable[i], SIGBREAKF_CTRL_C);
  1639.     /* Close all sockets */
  1640.     for (i = NOFILE - 1; i >= 0; i--) {
  1641.       CloseSocket(i);
  1642.     }
  1643.     /* Wait until all childs are terminated */
  1644.     while (builtins_started > 0) {
  1645.       WaitPort(dport);
  1646.       reapchild();
  1647.     }
  1648.  
  1649.     Forbid();
  1650.     sigbit = dport->dp_Port.mp_SigBit;
  1651.     dport->dp_Port.mp_Flags = PA_IGNORE;
  1652.     dport->dp_Port.mp_SigBit = (UBYTE)-1; /* braindead */
  1653.     dport->dp_Port.mp_SigTask = NULL;
  1654.     FreeSignal(sigbit);
  1655.     Permit();
  1656.   }
  1657. }
  1658.  
  1659. /*
  1660.  * Generic printing functions 
  1661.  */
  1662. void ASM 
  1663. stuffchar(REG(d0) char ch, REG(a3) struct CSource * sc)
  1664. {
  1665.   if (sc->CS_CurChr < sc->CS_Length 
  1666.       && (sc->CS_Buffer[sc->CS_CurChr] = ch))
  1667.     sc->CS_CurChr++;
  1668. }
  1669.  
  1670. static ULONG
  1671. csprintf(struct CSource *buf, const char *fmt, ...)
  1672. {
  1673.   ULONG start = buf->CS_CurChr;
  1674.   va_list ap;
  1675.  
  1676.   if (buf->CS_Length && buf->CS_CurChr < buf->CS_Length) {
  1677.     va_start(ap, fmt);
  1678.     RawDoFmt((STRPTR)fmt, ap, stuffchar, buf);
  1679.     va_end(ap);
  1680.     
  1681.     if (buf->CS_CurChr == buf->CS_Length) {
  1682.       buf->CS_CurChr--;            /* must NUL terminate */
  1683.     }      
  1684.     buf->CS_Buffer[buf->CS_CurChr] = '\0';
  1685.  
  1686.     return buf->CS_CurChr - start;
  1687.   } else {
  1688.     /* A pathological case */
  1689.     return 0;
  1690.   }
  1691. }
  1692.